import { count } from 'console';
import { Context, Schema, Session, h } from 'koishi';
import {} from 'koishi-plugin-adapter-onebot';
import {} from 'koishi-plugin-markdown-to-image-service';

export const inject = {
  required: ['markdownToImage'],
};


export const name = 'gemini-request'; // 插件名称，更具描述性
export const reusable = true    // 声明此插件可重用

export interface Config {
  enableGeminiCommand?: boolean; // 是否启用 /gemini 命令，默认为 true
  geminiCommandName?: string; // 用于调用 gemini 的命令名称，默认为 "gemini"
  enableAwaChatLogCommand?: boolean; // 是否启用 /awa_chat_log 命令，默认为 true
  awaChatLogCommandName?: string; // 用于调用 awa_chat_log 的命令名称，默认为 "awa_chat_log"
  geminiBackendUrl: string;
  geminiDefaultPrompt: string;

  defaultMsgCount: number; // 可选的默认消息数量
}

export const Config: Schema<Config> = Schema.intersect([

  Schema.object({
    enableGeminiCommand: Schema.boolean()
      .default(true)
      .description("是否启用 /gemini 命令"),
    geminiCommandName: Schema.string()
      .default("gemini")
      .description("用于调用 gemini 的命令名称"),
    enableAwaChatLogCommand: Schema.boolean()
      .default(true)
      .description("是否启用 /awa_chat_log 命令"),
    awaChatLogCommandName: Schema.string()
      .default("awa_chat_log")
      .description("用于调用 awa_chat_log 的命令名称"),
  }).description("命令设置"),

  Schema.object({
    geminiBackendUrl: Schema.string()
      .default("192.168.31.84:8629")
      .description("gemini后端地址，格式为 ip:port"),
    geminiDefaultPrompt: Schema.string()
      .default(" 请你以可爱猫娘的口吻回答，对这段聊天记录内容做总结，要求按照不同人做归类，谁大概说了什么内容，然后发我raw的markdown格式, 不要用代码块，只用#和*符号 多加点emoji。 所有人的名字按照 nickname - card的形式展示。人名用大号的字体并加粗。每个人的总结用一句话，尽量简介，不超过30字。   这里是聊天记录内容： ")
      .description("默认的gemini后端请求prompt。 紧随其后的就是${output}")
      .role('textarea', { rows: [2, 4] })
  }).description("gemini后端设置"),

  Schema.object({
    defaultMsgCount: Schema.number()
      .default(60)
      .description("默认获取的消息数量，如果不指定，则使用此值。"),
  })

])


export function apply(ctx: Context, config: Config) {

  // 构造后端的 URL
  const backendUrl = `http://${config.geminiBackendUrl}/gemini`;

  if ( config.enableGeminiCommand )
  ctx.command(`${config.geminiCommandName} <prompt>`)
    .action( async ( { session }, prompt ) => {
      if ( !prompt || prompt.trim().length === 0 ){
        await session.send(`${h.quote(session.messageId)}请提供一个有效的提示词（prompt）。`);
        return;
      }
      ctx.logger.info(`gemini命令被调用，参数：${prompt}`);
      try{
        const res = await ctx.http.post(backendUrl, {
          text: prompt
        });
        await session.send(`${h.quote(session.messageId)}${res.answer}`);
      } catch (error) {
        let errMsg = `向gemini后端请求数据失败。请联系开发者VincentZyu。\n\tgemini后端地址：${backendUrl}\n\t错误信息：${error}`;
        ctx.logger.error(errMsg);
        await session.send(errMsg);
      }

    })

  if ( config.enableAwaChatLogCommand)
  ctx.command(
    `${config.awaChatLogCommandName} [arg0_count:number]`, 
    '用Google Gemini总结最近的聊天记录'
  )
    .alias('acl', "聊天总结")
    .option('arg0_count', '-c, --count <arg0_count> 历史消息数量，默认为60条')
    .action( async ( { session, options } ) => {
      const acl_count = options.arg0_count ? options.arg0_count : config.defaultMsgCount;

      let argMsg = '[awa_chat_log]参数:\n';
      argMsg += `\t 🔢 acl_count = ${acl_count} \n`;
      argMsg += `\n\t正在生成中......`
      // argMsg += `typeof acl_count =  ${typeof String(acl_count)}`;
      const argMsgId = await session.send(h.quote(session.messageId) + argMsg);

      if (!session.guildId) {
        return '[awa_chat_log]命令只能在群聊中使用。';
      }

      try {
        const msgHistoryRes = await session.onebot._request(
          "get_group_msg_history",
          {
            group_id: session.guildId,
            count: String(acl_count) // 使用传入的消息数量或默认值
          }
        )

        const isResValid: boolean = msgHistoryRes 
          && msgHistoryRes.status === 'ok'
          && !!msgHistoryRes.data 
          && Array.isArray(msgHistoryRes.data.messages);

        if( !isResValid ){
          let invalidMsg = "[awa_chat_log]获取历史消息的结果不合法。";
          await session.send(invalidMsg);
          return;
        } 
            
        // await session.send(JSON.stringify(msgHistoryRes));
        // ctx.logger.info(msgHistoryRes);

        const processedMessages = msgHistoryRes.data.messages.map((msg: any) => {
          return {
            nickname: msg.sender ? msg.sender.nickname : '未知昵称',
            card: msg.sender ? msg.sender.card : '未知名片',
            raw_message: msg.raw_message || ''
          };
        });

        // 将处理后的对象数组转换为可读的字符串，并发送
        // 为了可读性，这里简单地 JSON.stringify 可能会导致消息过长或格式不佳
        // 更好的做法是遍历数组，按行或按块发送
        let output = '最近的聊天记录：\n';
        processedMessages.forEach((msg, index) => {
          output += `--- 消息 ${index + 1} ---\n`;
          output += `昵称: ${msg.nickname}\n`;
          output += `名片: ${msg.card}\n`;
          output += `内容: ${msg.raw_message}\n\n`;
        });

        // 由于 Koishi 的 session.send 可能有消息长度限制，
        // 如果消息很多，可能需要分批发送或截断。
        // 这里为了演示，直接发送，如果太长可能会失败。
        // await session.send(output);

        // 打印到 Koishi 日志中，方便调试
        // ctx.logger.info('处理后的消息记录:', output);

        ctx.logger.info(`${config.geminiBackendUrl}`) //print ip:port. eg: 192.168.31.84:8629

        // 拼接要发送给 Gemini 后端的 prompt
        const promptText = `${config.geminiDefaultPrompt}  ${output}`;

        try {
          // 调用你的 FastAPI 后端
          const geminiResponse = await ctx.http.post(backendUrl, {
            text: promptText
          });

          // 取出后端返回的结果
          const answer = geminiResponse?.answer || '喵呜~ 没有拿到有效的回答呢。';

          // 发送到群里
          // ctx.logger.info(`answer = ${answer}`);
          // await session.send(answer);

          const ansImageBuffer = await ctx.markdownToImage.convertToImage(answer);

          await session.send( h.image(ansImageBuffer, 'image/png') );

          await session.bot.deleteMessage(session.guildId, String(argMsgId));

        } catch (err) {
          const errmsg = `[awa_chat_log]向后端请求失败了喵：${err}`;
          ctx.logger.error(errmsg);
          await session.send(errmsg);
        }

      } catch ( e ){
        let errmsg = "[awa_chat_log]获取历史消息的时候发生错误: " + e;
        ctx.logger.error(errmsg);
        await session.send(errmsg);
      }


    })

    // ctx.on('message', async (session: Session) => {
    //   if ( !session.content.startsWith('/gemini') ){
    //     return;
    //   }

    //   const text = session.content.replace('/gemini', '').trim();

    //   try{
    //     const geminiResponse = await ctx.http.post(backendUrl, {
    //       text: text
    //     });

    //     // 取出后端返回的结果
    //     const answer = geminiResponse?.answer || '喵呜~ 没有拿到有效的回答呢。';
    //     await session.send(h.quote(session.messageId) + `gemini回答:\n\t${answer}`);

    //   } catch (e) {
    //     const errmsg = `[awa_chat_log]向后端请求失败了喵：${e}`;
    //     ctx.logger.error(errmsg);
    //     await session.send(errmsg);
    //   }
      
    // }); 

}